home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus Leser 15 / Amiga Plus Leser CD 15.iso / Tools / Development / yacas_alg / yacas_morphos / share / yacas / examples / tests.ys < prev   
Encoding:
Text File  |  2002-03-13  |  11.5 KB  |  527 lines
  1.  
  2.  
  3. /*******************************************************************
  4.    Test scripts moved to directory tests/
  5. ********************************************************************/   
  6.  
  7.  
  8. EndOfFile;
  9.  
  10.  
  11.  
  12.  
  13.  
  14. /* Test script for the Yacas computer algebra system.
  15.  * Copyright 1999 Ayal Pinkus
  16.  *
  17.  */
  18.  
  19. Use("testers.ys");
  20.  
  21. StartTests();
  22.  
  23. Clear(a,b);
  24.  
  25. NextTest("Testing some internal functions");
  26.  
  27. Verify(ConcatStrings("a","b","c"),"abc");
  28.  
  29. Verify(aa-aa,0);
  30. Testing("Apply");
  31. Verify(Apply("+",{2,3}),5);
  32. [
  33.   Local(x,y);
  34.   Verify(Apply({{x,y},x+y},{2,3}),5);
  35.   Verify(x,x);
  36.   Verify(y,y);
  37.  
  38.   Testing("ThreadingListables");
  39.   x:={bb,cc,dd};
  40.   Verify(Sin(aa*x),{Sin(aa*bb),Sin(aa*cc),Sin(aa*dd)});
  41. ];
  42.  
  43. Testing("Bases");
  44. Verify(ToBase(16,255),ff);
  45. Verify(FromBase(2,100),4);
  46.  
  47. Testing("Length");
  48. Verify(Length({a,b}),2);
  49. Verify(Length({}),0);
  50.  
  51. Testing("Nth");
  52. Verify(Nth({a,b},1),a);
  53. Verify({a,b,c}[2],b);
  54.  
  55. Testing("Concat");
  56. Verify(Concat({a,b},{c,d}),{a,b,c,d});
  57. Verify(Hold(Concat({a,b},{c,d})),Concat({a,b},{c,d}));
  58.  
  59. Testing("Rounding");
  60. Verify(Floor(1.2),1);
  61. Verify(Floor(-1.2),-2);
  62. Verify(Ceil(1.2),2);
  63. Verify(Ceil(-1.2),-1);
  64. Verify(Round(1.49),1);
  65. Verify(Round(1.51),2);
  66. Verify(Round(-1.49),-1);
  67. Verify(Round(-1.51),-2);
  68.  
  69. Testing("Pslq");
  70. Verify(Pslq({ Pi+2*Exp(1) , Pi , Exp(1) },20),{1,-1,-2});
  71. Verify(Pslq({ 2*Pi+3*Exp(1) , Pi , Exp(1) },20),{1,-2,-3});
  72.  
  73. Testing("ListOperations");
  74. Verify(Head({a,b,c}),a);
  75. Verify(Tail({a,b,c}),{b,c});
  76. Verify(DestructiveReverse({a,b,c}),{c,b,a});
  77. Verify(UnList({a,b,c}),a(b,c));
  78. Verify(Listify(a(b,c)),{a,b,c});
  79.  
  80. Verify(Delete({a,b,c},2),{a,c});
  81. Verify(Insert({a,c},2,b),{a,b,c});
  82.  
  83. Testing("Matrix predicates");
  84. Verify(IsHermitean({{0,I},{-I,0}}),True);
  85. Verify(IsHermitean({{0,I},{-I,1}}),True);
  86. Verify(IsHermitean({{0,I},{-2*I,0}}),False);
  87.  
  88. Verify(IsUnitary({{0,I},{-I,0}}),True);
  89. Verify(IsUnitary({{0,I},{-I,1}}),False);
  90. Verify(IsUnitary({{0,I},{-2*I,0}}),False);
  91.  
  92. Testing("Boolean Operations");
  93. Verify(False And False,False);
  94. Verify(True And False,False);
  95. Verify(False And True,False);
  96. Verify(True And True,True);
  97.  
  98. Verify(False Or False,False);
  99. Verify(True Or False,True);
  100. Verify(False Or True,True);
  101. Verify(True Or True,True);
  102.  
  103. Verify(Not(True),False);
  104. Verify(Not(False),True);
  105.  
  106. Verify(Equals(a,b),False);
  107. Verify(Equals(a,a),True);
  108. Verify(Equals({a,b},{a}),False);
  109. Verify(Equals({a,b},{a,b}),True);
  110.  
  111. Testing("NumberCompares");
  112. Verify(LessThan(2,3),True);
  113. Verify(LessThan(3,2),False);
  114. Verify(GreaterThan(2,3),False);
  115. Verify(GreaterThan(3,2),True);
  116.  
  117. Verify(.1<2,True);
  118. Verify(0.1<2,True);
  119. Verify(.3<2,True);
  120. Verify(.1>2,False);
  121. Verify(0.1>2,False);
  122. Verify(.3>2,False);
  123.  
  124. Verify(2<.1,False);
  125. Verify(2<0.1,False);
  126. Verify(2<.3,False);
  127. Verify(2>.1,True);
  128. Verify(2>0.1,True);
  129. Verify(2>.3,True);
  130.  
  131.  
  132. Verify(Atom("a"),a);
  133. Verify(String(a),"a");
  134.  
  135. Testing("Predicates");
  136. Verify(IsFunction(a(b)),True);
  137. Verify(IsFunction(a),False);
  138. Verify(IsList({a,b,c}),True);
  139. Verify(IsList(a),False);
  140. Verify(IsAtom({a,b,c}),False);
  141. Verify(IsAtom(a),True);
  142. Verify(IsAtom(123),True);
  143.  
  144. Verify(IsNumber(123),True);
  145. Verify(IsNumber(123.123),True);
  146. Verify(IsNumber(a),False);
  147. Verify(IsNumber({a}),False);
  148.  
  149. Verify(IsInteger(123),True);
  150. Verify(IsInteger(123.123),False);
  151. Verify(IsInteger(a),False);
  152. Verify(IsInteger({a}),False);
  153.  
  154. Testing("IntegerOperations");
  155. Verify(1<<10,1024);
  156. Verify(1024>>10,1);
  157. Verify(Mod(10,3),1);
  158. Verify(Div(10,3),3);
  159. Verify(MathGcd(55,10),5);
  160.  
  161. Testing("LocalVariables");
  162. [
  163.   Verify(IsBound({}),False);
  164.   Local(a);
  165.   Verify(IsBound(a),False);
  166.   a:=1;
  167.   Verify(IsBound(a),True);
  168.   Clear(a);
  169.   Verify(IsBound(a),False);
  170. ];
  171.  
  172. Testing("MapSingle");
  173. Verify(MapSingle("!",{1,2,3,4}),{1,2,6,24});
  174.  
  175.  
  176. /* Example: using the for function. */
  177. Function("count",{from,to})
  178. [
  179.    Local(i);
  180.    Local(sum);
  181.    Set(sum,0);
  182.    For(i:=from,i<to,i:=i+1)
  183.    [
  184.      Set(sum,sum+i);
  185.    ];
  186.    sum;
  187. ];
  188.  
  189. Testing("Function definitions");
  190. Verify(count(1,11),55);
  191.  
  192. Retract("count",2);
  193.  
  194. [
  195.   Local(l);
  196.   l:={1,2,3};
  197.   DestructiveDelete(l,1);
  198.   Verify(l,{2,3});
  199.   DestructiveInsert(l,1,1);
  200.   Verify(l,{1,2,3});
  201.   l[1] := 2;
  202.   Verify(l,{2,2,3});
  203.   l[1] := 1;
  204.   DestructiveDelete(l,3);
  205.   Verify(l,{1,2});
  206.   DestructiveInsert(l,3,3);
  207.   Verify(l,{1,2,3});
  208.   DestructiveDelete(FlatCopy(l),1);
  209.   Verify(l,{1,2,3});
  210. ];
  211.  
  212. Verify(Table(i!,i,1,4,1),{1,2,6,24});
  213. Verify(Permutations({a,b,c}),{{a,b,c},{a,c,b},{c,a,b},{b,a,c},{b,c,a},{c,b,a}});
  214.  
  215. Verify(Type(Cos(x)),"Cos");
  216. Verify(NrArgs(Cos(x)),1);
  217. Verify(Contains({a,b,c},b),True);
  218. Verify(Contains({a,b,c},d),False);
  219. Verify(Append({a,b,c},d),{a,b,c,d});
  220. Verify(RemoveDuplicates({a,b,b,c}),{a,b,c});
  221. Verify(Count({a,b,b,c},b),2);
  222. Verify(VarList(x*Cos(x)),{x});
  223.  
  224.  
  225. NextTest("Testing math stuff");
  226. Verify(1*a,a);
  227. Verify(a*1,a);
  228. Verify(0*a,0);
  229. Verify(a*0,0);
  230. Verify(aa-aa,0);
  231.  
  232. Verify(2+3,5);
  233. Verify(2*3,6);
  234.  
  235. Verify(2+3*4,14);
  236. Verify(3*4+2,14);
  237. Verify(3*(4+2),18);
  238. Verify((4+2)*3,18);
  239.  
  240. Verify(15/5,3);
  241.  
  242.  Verify(-2+3,1);
  243. Verify(-2.01+3.01,1);
  244.  
  245. Verify(0+a,a);
  246. Verify(a+0,a);
  247.  
  248. Verify(4!,24);
  249. Verify(Bin(2,1),2);
  250.  
  251. Testing("Derivatives");
  252. Verify(D(x) a,0);
  253. Verify(D(x) x,1);
  254. Verify(D(x) x+x,2);
  255. Verify(D(x) x*x,2*x);
  256. Verify(D(x) D(x) Sin(x),-Sin(x));
  257.  
  258. Verify(Apply("+",{2,3}),5);
  259.  
  260. Testing("BubbleSort");
  261. Verify(BubbleSort({2,3,1},"<"),{1,2,3});
  262. Verify(BubbleSort({2,3,1},">"),{3,2,1});
  263.  
  264. Testing("LeviCivita");
  265. Verify(LeviCivita({1,2,3}),1);
  266. Verify(LeviCivita({2,1,3}),-1);
  267. Verify(LeviCivita({1,1,3}),0);
  268.  
  269. Testing("VectorProducts");
  270. [
  271.   Local(l,m,n);
  272.   l:={1,0,0};
  273.   m:={0,1,0};
  274.   n:={0,0,1};
  275.  
  276.   Verify(l X m, {0,0,1});
  277.   Verify(m X n, {1,0,0});
  278.   Verify(n X l, {0,1,0});
  279.   Verify(l X n, {0,-1,0});
  280.  
  281.   Verify(l . m, 0);
  282.   Verify(m . n, 0);
  283.   Verify(n . l, 0);
  284.  
  285.   Verify(l . l, 1);
  286. ];
  287.  
  288. Testing("UnaryFunctionInverses");
  289. Verify(Sin(ArcSin(a)),a);
  290. Verify(Cos(ArcCos(a)),a);
  291. Verify(Tan(ArcTan(a)),a);
  292. Verify(ArcSin(Sin(a)),a);
  293. Verify(ArcCos(Cos(a)),a);
  294. Verify(ArcTan(Tan(a)),a);
  295.  
  296. Verify(2+I*3,Complex(2,3));
  297. Verify(Re(2+I*3),2);
  298. Verify(Im(2+I*3),3);
  299. Verify(ZeroVector(3),{0,0,0});
  300. Verify(BaseVector(2,3),{0,1,0});
  301. Verify(Identity(3),{{1,0,0},{0,1,0},{0,0,1}});
  302.  
  303. Testing("Solve");
  304. Verify(Solve(a+x*y==z,x),(z-a)/y);
  305. /*TODO PSolve, MatrixSolve*/
  306.  
  307.  
  308.  
  309. NextTest("Basic calculations");
  310. Verify(3 + 2 , 5);
  311. Verify(3-7, -4);
  312. Verify(1 = 2 , 0 = -1);
  313. Verify(5 ^ 2 , 25);
  314.  
  315. [
  316.   Local(a,b);
  317.  
  318. /* Strangeness: change variable below into a, and the crossproducts
  319.  * later on fail!
  320.  */
  321.   a:={1,2,3};
  322.   b:={3,1,5};
  323.   Verify( a . b , 20);
  324.   Verify(CrossProduct({1,2,3} , {4,2,5}) , {4,7,-6});
  325. ];
  326. Verify(aa,Hold(aa));
  327.  
  328.  
  329. NextTest("Inproduct");
  330. a:={1,2,3};
  331. b:={3,1,5};
  332. Verify( a . b , 20);
  333.  
  334. Verify(CrossProduct({1,2,3} , {4,2,5}) , {4,7,-6});
  335. Verify({1,2,3} X {4,2,5},{4,7,-6});
  336. Clear(a,b);
  337.  
  338. NextTest("Identity matrices");
  339. Verify(Identity(4),
  340.    { {1,  0,  0,  0} ,
  341.      {0,  1,  0,  0} ,
  342.      {0,  0,  1,  0} ,
  343.      {0,  0,  0,  1} });
  344.  
  345. NextTest("VarList");
  346. Verify(VarList(x^2+y^3) , {x , y});
  347. Verify(List(1,2,3),{1 , 2 , 3});
  348.  
  349.  
  350. Verify(IsZero(0.000),True);
  351.  
  352. Verify(Factorize(i,1,3,i),6);
  353. Clear(a,b,c,d);
  354. Verify(Intersection({aa,b,c},{b,c,d}),{b,c});
  355. Verify(Union({aa,b,c},{b,c,d}),{aa,b,c,d});
  356. Verify(Difference({aa,b,c},{b,c,d}),{aa});
  357.  
  358.  
  359.  
  360.  
  361. NextTest("Check linear algebra");
  362. /* Normalize */
  363. Testing("Normalize");
  364. Verify(N(Normalize({3,4})),N({3/5,4/5}));
  365. /* DiagonalMatrix */
  366. Testing("DiagonalMatrix");
  367. Verify(DiagonalMatrix({2,3,4}),{{2,0,0},{0,3,0},{0,0,4}});
  368. /* ZeroMatrix */
  369. Testing("ZeroMatrix");
  370. Verify(ZeroMatrix(2,3),{{0,0,0},{0,0,0}});
  371. /* Transpose */
  372. Testing("Transpose");
  373. Verify(Transpose({{a,b},{c,d}}),{{a,c},{b,d}});
  374. /* Determinant */
  375. Testing("Determinant");
  376. Verify(Determinant({{2,3},{3,1}}),-7);
  377.  
  378. ll:={ {1,2,3},
  379.       {2,-1,4},
  380.       {3,4,3}
  381.     };
  382. /* CoFactor */
  383. Testing("CoFactor");
  384. Verify(N(CoFactor(ll,1,2)),6);
  385. /* Minor */
  386. Testing("Minor");
  387. Verify(N(Minor(ll,1,2)),-6);
  388. /* Inverse */
  389. Testing("Inverse");
  390. Verify(Inverse(ll)*ll,Identity(3));
  391. /* SolveMatrix */
  392. Testing("SolveMatrix");
  393. Verify(ll*SolveMatrix(ll,{1,2,3}),{1,2,3});
  394. /* Trace */
  395. Testing("Trace");
  396. Verify(Trace(ll),1-1+3);
  397. /* IsVector */
  398. Verify(IsList(ll),True);
  399. Verify(IsList({1,2,3}),True);
  400. /* IsMatrix */
  401. Verify(IsMatrix(ll),True);
  402. Clear(ll);
  403.  
  404. NextTest("Test rationals");
  405. Verify(2/5,Hold(2/5));
  406. Verify(N(2/5),0.4);
  407. Verify(IsRational(2/5),True);
  408. Verify(Numer(2/5),2);
  409. Verify(Denom(2/5),5);
  410.  
  411. VerifyArithmetic(10,5,8);
  412. VerifyArithmetic(10000000000,5,8);
  413. VerifyArithmetic(10,50,80);
  414. VerifyArithmetic(10000,50,88);
  415.  
  416.  
  417. NextTest("Polynomials");
  418. TestYacas(Expand((1+x)^2),1+2*x+x^2);
  419.  
  420. /* Test Simplify() */
  421. NextTest("Simplify");
  422.  
  423. TestYacas( Simplify((x+y)*(x-y)-(x+y)^2), -2*y^2-2*x*y );
  424. TestYacas( Simplify(1+x+x+3*y-4*(x+y+2)), -2*x-y-7 );
  425. TestYacas( Simplify((1+I)^4), -4 );
  426. TestYacas( Simplify((x-y)/(x*y)), 1/y-1/x );
  427. TestYacas( Simplify((x+I)^4), x^4+4*x^3*I-6*x^2-4*x*I+1 );
  428.  
  429. /*Serge: these are not handled yet ;-)
  430. TestYacas( Simplify((x^2-y^2)/(x+y)), x-y );
  431. */
  432.  
  433.  
  434. NextTest("Tensors");
  435.  
  436. TestYacas(TSimplify( TSum({j}) Delta(i,j)*v(j) ),v(i));
  437. TestYacas(TSimplify( TSum({j,i}) Delta(i,j)*Delta(i,j) ), Ndim);
  438. TestYacas(TSimplify( TSum({j,i}) Delta(i,j)*Delta(j,i) ), Ndim);
  439. TestYacas(TSimplify( TSum({j}) Delta(i,j)*Delta(j,k) ), Delta(i,k));
  440. TestYacas(TSimplify( TSum({i}) v(i)*v(i) ), TSum({i})(v(i)^2));
  441. Retract("v",1);
  442. RuleBase("v",{ii});
  443. f(i,j):=v(i)*v(j);
  444. TestYacas(f(i,i),v(i)^2);
  445. TestYacas(TSimplify( TSum({i}) f(i,i) ),TSum({i})(v(i)^2));
  446. TestYacas(TSimplify( TSum({j}) Delta(i,j)*f(j,k) ),v(i)*v(k));
  447.  
  448. TestYacas(TSimplify(TSum({i,j}) Delta(i,j)*f(i,j) ),  TSum({j})v(j)^2);
  449. TestYacas(TSimplify(TSum({i})X(j)*TD(i)X(i)),  Ndim*X(j));
  450. TestYacas(TSimplify(TSum({i}) TD(i)(X(i)*X(j)) ), Ndim*X(j)+X(j));
  451. TestYacas(TSimplify(TSum({i}) X(i)*TD(i)X(j) ), X(j));
  452. TestYacas(TSimplify(TSum({i})TD(i)v(i)),  TSum({i})TD(i)v(i));
  453.  
  454. TestYacas(TSimplify(TSum({i,j})TD(i)TD(j)(X(i)*X(j))), Ndim+Ndim^2);
  455. TestYacas(TSimplify(TSum({i})TD(i)(X(i)*X(j)*X(j))),  Ndim*X(j)^2+2*X(j)^2);
  456. TestYacas(TSimplify(TSum({i,j,k})TD(i)TD(j)TD(k)(X(i)*X(j)*X(k))),  3*Ndim^2+2*Ndim+Ndim^3);
  457.  
  458. NextTest("Propositional logic theorem prover");
  459. Verify(CanProve(( (a=>b) And (b=>c)=>(a=>c) )),True);
  460. Verify(CanProve(a Or Not a)                   ,True);
  461. Verify(CanProve(True Or a)                 ,True);
  462. Verify(CanProve(False Or a)                ,a   );
  463. Verify(CanProve(a And Not a)                   ,False);
  464. Verify(CanProve(a Or b Or (a And b))               ,a Or b  );
  465.  
  466.  
  467. NextTest("Testing simplifying nested radicals");
  468. TestYacas(RadSimp(Sqrt(9+4*Sqrt(2))), 1+Sqrt(8));
  469. TestYacas(RadSimp(Sqrt(5+2*Sqrt(6))+Sqrt(5-2*Sqrt(6))),Sqrt(12));
  470. TestYacas(RadSimp(Sqrt(14+3*Sqrt(3+2*Sqrt(5-12*Sqrt(3-2*Sqrt(2)))))), 3+Sqrt(2));
  471.  
  472.  
  473. NextTest("Regression on bug reports");
  474. Verify(N(Sin(a)),Sin(a));
  475. Verify(CanProve(P Or (Not P And Not Q)),P Or Not Q);
  476. Verify(Cos(0),1);
  477. Verify(Infinity/Infinity,Undefined);
  478. Verify(Sqrt(Infinity),Infinity);
  479. Verify(1^Infinity,Undefined);
  480. Verify((-2)*Infinity,-Infinity);
  481. Verify(Infinity*0,Undefined);
  482. Verify(Limit(x,Infinity) (-x^2+1)/(x+2),-Infinity);
  483. Verify(Limit(x,-Infinity)Exp(2*x),0);
  484. Verify(Limit(x,Infinity)(1+1/x)^x,Exp(1));
  485. Verify(Limit(x,Infinity)(1+2/x)^x,Exp(2));
  486. Verify(Limit(x,Infinity)(1+1/x)^(2*x),Exp(2));
  487. Verify(Limit(x,Infinity)-2*x,-Infinity);
  488. Verify(Limit(x,Infinity)(x^2+1)/(-x^3+1),0);
  489.  
  490. Verify(Limit(x,0)1/x,Undefined);
  491. Verify(Limit(x,0,Right)1/x,Infinity);
  492. Verify(Limit(x,0,Left)1/x,-Infinity);
  493.  
  494. Verify([Local(a);a:=0.1;Simplify((a*b*c)/(a*c*b));],1);
  495. Verify(CanProve(P Or (Not P And Not Q)),P Or Not Q);
  496. Verify(CanProve(A>0 And A<=0),False);
  497. Verify(CanProve(A>0 Or A<=0),True);
  498. Verify(A<0,A<0);
  499. Verify(A>0,A>0);
  500. TestYacas(Arg(Exp(2*I*Pi/3)),Pi-Pi/3);
  501.  
  502. TestYacas(Content(1/2*x+1/2),1/2);
  503. TestYacas(PrimitivePart(1/2*x+1/2),x+1);
  504. TestYacas(Content(1/2*x+1/3),1/6);
  505. TestYacas(PrimitivePart(1/2*x+1/3),3*x+2);
  506.  
  507.  
  508. /*
  509. Verify();
  510. Verify();
  511. Verify();
  512. Verify();
  513. Verify();
  514. Verify();
  515. Verify();
  516. Verify();
  517. Verify();
  518. Verify();
  519. */
  520.  
  521.  
  522. NextTest("Tests completed");
  523. NewLine();
  524.  
  525. Retract("Next",1);
  526.  
  527.